// 引入模型和工具
const { Product, Category, Sequelize } = require('../../models');
const { formatFieldNames } = require('../../utils/format');
const { Op } = Sequelize;

// API基础URL
const API_BASE_URL = process.env.NODE_ENV === 'production'
  ? process.env.API_BASE_URL || 'https://api.example.com'
  : `http://localhost:${process.env.PORT || 3001}`;

// 字段映射表
const FIELD_MAP = {
  categoryId: 'category_id',
  originalPrice: 'original_price'
};

class ProductService {
  /**
   * 创建商品
   */
  async createProduct(data) {
    // 将驼峰命名转换为下划线命名
    const formattedData = formatFieldNames(data, FIELD_MAP);
    
    console.log('原始商品数据:', data);
    console.log('格式化后的商品数据:', formattedData);
    
    // 确保必要字段存在且不为null
    if (!formattedData.category_id) {
      throw new Error('商品分类不能为空');
    }
    
    if (!formattedData.original_price && formattedData.original_price !== 0) {
      throw new Error('商品原价不能为空');
    }
    
    // 处理图片路径格式 - 统一保存文件名格式
    if (formattedData.cover) {
      // 从路径中提取文件名
      formattedData.cover = this.extractFilename(formattedData.cover);
      console.log('处理后的封面图片名:', formattedData.cover);
    }
    
    // 处理图库路径
    if (formattedData.gallery) {
      if (typeof formattedData.gallery === 'string') {
        try {
          formattedData.gallery = JSON.parse(formattedData.gallery);
        } catch (e) {
          console.error('解析gallery字符串失败:', e);
          formattedData.gallery = formattedData.gallery ? [formattedData.gallery] : [];
        }
      }
      
      // 确保gallery是数组
      if (Array.isArray(formattedData.gallery)) {
        // 对数组中的每个URL提取文件名
        formattedData.gallery = formattedData.gallery.map(url => this.extractFilename(url));
        console.log('处理后的图库:', formattedData.gallery);
      }
    }
    
    return await Product.create(formattedData);
  }

  /**
   * 更新商品
   */
  async updateProduct(id, data) {
    const product = await Product.findByPk(id);
    if (!product) {
      throw new Error('商品不存在');
    }
    
    // 将驼峰命名转换为下划线命名
    const formattedData = formatFieldNames(data, FIELD_MAP);
    
    console.log('原始更新数据:', data);
    console.log('格式化后的更新数据:', formattedData);
    
    // 处理图片路径格式 - 统一保存文件名格式
    if (formattedData.cover) {
      // 从路径中提取文件名
      formattedData.cover = this.extractFilename(formattedData.cover);
      console.log('处理后的封面图片名:', formattedData.cover);
    }
    
    // 处理图库路径
    if (formattedData.gallery) {
      if (typeof formattedData.gallery === 'string') {
        try {
          formattedData.gallery = JSON.parse(formattedData.gallery);
        } catch (e) {
          console.error('解析gallery字符串失败:', e);
          formattedData.gallery = formattedData.gallery ? [formattedData.gallery] : [];
        }
      }
      
      // 确保gallery是数组
      if (Array.isArray(formattedData.gallery)) {
        // 对数组中的每个URL提取文件名
        formattedData.gallery = formattedData.gallery.map(url => this.extractFilename(url));
        console.log('处理后的图库:', formattedData.gallery);
      }
    }
    
    return await product.update(formattedData);
  }

  /**
   * 删除商品
   */
  async deleteProduct(id) {
    const product = await Product.findByPk(id);
    if (!product) {
      throw new Error('商品不存在');
    }
    return await product.destroy();
  }

  /**
   * 获取商品详情
   */
  async getProductById(id) {
    console.log(`服务层开始查询商品详情，ID: ${id}`);
    const product = await Product.findByPk(id, {
      include: [{
        model: Category,
        as: 'category',
        attributes: ['id', 'name']
      }]
    });
    
    if (!product) {
      console.log(`未找到ID为 ${id} 的商品`);
      return null;
    }
    
    // 将商品对象转换为普通对象
    const productData = product.toJSON();
    
    // 处理商品图片URL
    this.formatProductImages(productData);
    
    console.log(`找到商品详情:`, JSON.stringify(productData).slice(0, 300) + '...');
    
    // 返回处理后的商品对象
    return productData;
  }
  
  /**
   * 格式化产品图片
   * @param {Object} product - 产品数据
   */
  formatProductImages(product) {
    if (!product) return product;
    
    // 用于记录处理前后的URL，便于调试
    const originalUrlInfo = {
      cover: product.cover,
      gallery: product.gallery
    };
    
    // 处理封面图片
    if (product.cover) {
      // 检查cover是否已经是完整URL
      if (product.cover.startsWith('http://') || product.cover.startsWith('https://')) {
        console.log('封面图已经是完整URL:', product.cover);
      } else {
        // 如果cover是文件名，构建API URL
        if (!product.cover.includes('/')) {
          product.cover = `${API_BASE_URL}/api/upload/get/${product.cover}`;
        }
        // 如果cover是相对路径，但不是API路径，转换为API路径
        else if (!product.cover.includes('/api/')) {
          const filename = product.cover.split('/').pop();
          product.cover = `${API_BASE_URL}/api/upload/get/${filename}`;
        }
        // 如果是API路径但不完整，添加域名
        else if (product.cover.startsWith('/api/')) {
          product.cover = `${API_BASE_URL}${product.cover}`;
        }
      }
    }
    
    // 处理图库
    if (product.gallery) {
      let gallery = product.gallery;
      
      // 如果是字符串，尝试解析为JSON
      if (typeof gallery === 'string') {
        try {
          gallery = JSON.parse(gallery);
        } catch (e) {
          console.error('解析gallery字符串失败:', e);
          gallery = gallery ? [gallery] : [];
        }
      }
      
      // 确保gallery是数组
      if (Array.isArray(gallery)) {
        product.gallery = gallery.map(url => {
          // 跳过已经是完整URL的情况
          if (url.startsWith('http://') || url.startsWith('https://')) {
            return url;
          }
          
          // 如果是文件名，构建API URL
          if (!url.includes('/')) {
            return `${API_BASE_URL}/api/upload/get/${url}`;
          }
          // 如果是相对路径，但不是API路径，转换为API路径
          else if (!url.includes('/api/')) {
            const filename = url.split('/').pop();
            return `${API_BASE_URL}/api/upload/get/${filename}`;
          }
          // 如果是API路径但不完整，添加域名
          else if (url.startsWith('/api/')) {
            return `${API_BASE_URL}${url}`;
          }
          
          return url;
        });
      }
    }
    
    console.log('图片URL格式化前:', originalUrlInfo);
    console.log('图片URL格式化后:', {
      cover: product.cover,
      gallery: product.gallery
    });
    
    return product;
  }

  /**
   * 获取商品列表
   */
  async getProducts(params) {
    try {
      const { page = 1, pageSize = 10, categoryId, keyword, status } = params;
      const where = {};
      
      console.log('获取商品列表请求参数:', params);
      
      // 只有当categoryId有值且不为空字符串时才添加到查询条件
      if (categoryId !== undefined && categoryId !== null && categoryId !== '') {
        where.category_id = categoryId;
      }
      
      // 只有当keyword有值且不为空字符串时才添加到查询条件
      if (keyword !== undefined && keyword !== null && keyword !== '') {
        where.name = {
          [Op.like]: `%${keyword}%`
        };
      }
      
      // 只有当status有明确的值(0或1)时才添加到查询条件
      if (status !== undefined && status !== null && status !== '') {
        where.status = status;
      }

      console.log('最终查询条件:', where);

      // 设置合理的超时时间，避免查询时间过长
      const findPromise = Product.findAndCountAll({
        where,
        include: [{
          model: Category,
          as: 'category',
          attributes: ['id', 'name']
        }],
        offset: (page - 1) * pageSize,
        limit: parseInt(pageSize),
        order: [['create_time', 'DESC']]
      });

      // 添加超时处理
      const timeoutPromise = new Promise((_, reject) => {
        setTimeout(() => reject(new Error('查询超时，请稍后再试')), 10000); // 10秒超时
      });

      // 使用Race竞争，如果查询超过10秒，则返回超时错误
      const { count, rows } = await Promise.race([findPromise, timeoutPromise]);

      console.log(`查询到 ${count} 条商品记录`);

      // 处理分类名称，防止关联查询问题
      const productList = rows.map(product => {
        const item = product.toJSON();
        if (!item.category) {
          item.categoryName = '未分类';
        } else {
          item.categoryName = item.category.name;
        }
        
        // 处理商品图片URL
        this.formatProductImages(item);
        
        return item;
      });

      return {
        list: productList,
        total: count
      };
    } catch (error) {
      console.error('获取商品列表出错:', error);
      // 重新抛出经过处理的错误，提供更友好的错误信息
      if (error.message.includes('查询超时')) {
        throw new Error('查询超时，请稍后再试');
      } else if (error.name === 'SequelizeConnectionError') {
        throw new Error('数据库连接错误，请稍后再试');
      } else {
        throw new Error('获取商品列表失败: ' + (error.message || '未知错误'));
      }
    }
  }

  /**
   * 更新商品状态
   */
  async updateProductStatus(id, status) {
    try {
      console.log(`正在更新商品状态，ID: ${id}, 状态: ${status}, 类型: ${typeof status}`);
      
      // 确保状态值为数字
      let statusValue = parseInt(status, 10);
      
      // 确保状态值合法 (0 或 1)
      if (statusValue !== 0 && statusValue !== 1) {
        console.warn(`商品状态值异常: ${statusValue}，重置为默认值1`);
        statusValue = 1;
      }
      
      const product = await Product.findByPk(id);
      if (!product) {
        throw new Error('商品不存在');
      }
      
      console.log(`找到商品: ${product.name}, 当前状态: ${product.status}, 更新为: ${statusValue}`);
      const updated = await product.update({ status: statusValue });
      
      return {
        list: [updated],
        total: 1
      };
    } catch (error) {
      console.error(`更新商品状态失败, ID: ${id}, 状态: ${status}`, error);
      throw error;
    }
  }

  /**
   * 批量删除商品
   */
  async batchDeleteProducts(ids) {
    await Product.destroy({
      where: {
        id: {
          [Op.in]: ids
        }
      }
    });
    return {
      list: [],
      total: 0
    };
  }

  /**
   * 批量更新商品状态
   */
  async batchUpdateStatus(ids, status) {
    try {
      console.log(`批量更新商品状态，IDs: [${ids.join(', ')}], 状态: ${status}, 类型: ${typeof status}`);
      
      // 确保状态值为数字
      let statusValue = parseInt(status, 10);
      
      // 确保状态值合法 (0 或 1)
      if (statusValue !== 0 && statusValue !== 1) {
        console.warn(`商品状态值异常: ${statusValue}，重置为默认值1`);
        statusValue = 1;
      }
      
      await Product.update(
        { status: statusValue },
        {
          where: {
            id: {
              [Op.in]: ids
            }
          }
        }
      );
      
      return {
        list: [],
        total: 0
      };
    } catch (error) {
      console.error(`批量更新商品状态失败, IDs: [${ids.join(', ')}], 状态: ${status}`, error);
      throw error;
    }
  }

  /**
   * 从URL或路径中提取文件名
   * @param {string} url - URL或路径
   * @returns {string} 文件名
   */
  extractFilename(url) {
    if (!url) return '';
    
    console.log('提取文件名，原始URL:', url);
    
    try {
      // 如果是完整URL
      if (url.startsWith('http')) {
        const urlObj = new URL(url);
        // 处理/api/upload/get/路径格式
        if (urlObj.pathname.includes('/api/upload/get/')) {
          const filename = urlObj.pathname.split('/').pop();
          console.log('从API URL提取的文件名:', filename);
          return filename;
        }
        // 处理/uploads/路径格式
        else if (urlObj.pathname.includes('/uploads/')) {
          const filename = urlObj.pathname.split('/').pop();
          console.log('从uploads URL提取的文件名:', filename);
          return filename;
        }
      }
      
      // 处理/api/upload/get/路径格式
      if (url.includes('/api/upload/get/')) {
        const filename = url.split('/api/upload/get/').pop();
        console.log('从API路径提取的文件名:', filename);
        return filename;
      }
      
      // 处理/uploads/路径格式
      if (url.includes('/uploads/')) {
        const filename = url.split('/uploads/').pop().split('/').pop();
        console.log('从uploads路径提取的文件名:', filename);
        return filename;
      }
      
      // 如果没有路径分隔符，可能已经是文件名
      if (!url.includes('/')) {
        console.log('URL可能已经是文件名:', url);
        return url;
      }
      
      // 最后尝试提取路径中的最后一部分作为文件名
      const parts = url.split('/');
      const filename = parts[parts.length - 1];
      console.log('从路径提取的文件名:', filename);
      return filename;
    } catch (error) {
      console.error('提取文件名失败:', error);
      // 错误情况下返回原始URL
      return url;
    }
  }
}

module.exports = new ProductService(); 